home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / xfs / xfs_quota.h < prev    next >
C/C++ Source or Header  |  2005-10-18  |  14KB  |  357 lines
  1. /*
  2.  * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify it
  5.  * under the terms of version 2 of the GNU General Public License as
  6.  * published by the Free Software Foundation.
  7.  *
  8.  * This program is distributed in the hope that it would be useful, but
  9.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11.  *
  12.  * Further, this software is distributed without any warranty that it is
  13.  * free of the rightful claim of any third person regarding infringement
  14.  * or the like.  Any license provided herein, whether implied or
  15.  * otherwise, applies only to this software file.  Patent licenses, if
  16.  * any, provided herein do not apply to combinations of this program with
  17.  * other software, or any other product whatsoever.
  18.  *
  19.  * You should have received a copy of the GNU General Public License along
  20.  * with this program; if not, write the Free Software Foundation, Inc., 59
  21.  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22.  *
  23.  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24.  * Mountain View, CA  94043, or:
  25.  *
  26.  * http://www.sgi.com
  27.  *
  28.  * For further information regarding this notice, see:
  29.  *
  30.  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31.  */
  32. #ifndef __XFS_QUOTA_H__
  33. #define __XFS_QUOTA_H__
  34.  
  35. /*
  36.  * The ondisk form of a dquot structure.
  37.  */
  38. #define XFS_DQUOT_MAGIC        0x4451        /* 'DQ' */
  39. #define XFS_DQUOT_VERSION    (u_int8_t)0x01    /* latest version number */
  40.  
  41. /*
  42.  * uid_t and gid_t are hard-coded to 32 bits in the inode.
  43.  * Hence, an 'id' in a dquot is 32 bits..
  44.  */
  45. typedef __int32_t    xfs_dqid_t;
  46.  
  47. /*
  48.  * Eventhough users may not have quota limits occupying all 64-bits,
  49.  * they may need 64-bit accounting. Hence, 64-bit quota-counters,
  50.  * and quota-limits. This is a waste in the common case, but hey ...
  51.  */
  52. typedef __uint64_t    xfs_qcnt_t;
  53. typedef __uint16_t    xfs_qwarncnt_t;
  54.  
  55. /*
  56.  * This is the main portion of the on-disk representation of quota
  57.  * information for a user. This is the q_core of the xfs_dquot_t that
  58.  * is kept in kernel memory. We pad this with some more expansion room
  59.  * to construct the on disk structure.
  60.  */
  61. typedef struct    xfs_disk_dquot {
  62. /*16*/    u_int16_t    d_magic;    /* dquot magic = XFS_DQUOT_MAGIC */
  63. /*8 */    u_int8_t    d_version;    /* dquot version */
  64. /*8 */    u_int8_t    d_flags;    /* XFS_DQ_USER/PROJ/GROUP */
  65. /*32*/    xfs_dqid_t    d_id;        /* user,project,group id */
  66. /*64*/    xfs_qcnt_t    d_blk_hardlimit;/* absolute limit on disk blks */
  67. /*64*/    xfs_qcnt_t    d_blk_softlimit;/* preferred limit on disk blks */
  68. /*64*/    xfs_qcnt_t    d_ino_hardlimit;/* maximum # allocated inodes */
  69. /*64*/    xfs_qcnt_t    d_ino_softlimit;/* preferred inode limit */
  70. /*64*/    xfs_qcnt_t    d_bcount;    /* disk blocks owned by the user */
  71. /*64*/    xfs_qcnt_t    d_icount;    /* inodes owned by the user */
  72. /*32*/    __int32_t    d_itimer;    /* zero if within inode limits if not,
  73.                        this is when we refuse service */
  74. /*32*/    __int32_t    d_btimer;    /* similar to above; for disk blocks */
  75. /*16*/    xfs_qwarncnt_t    d_iwarns;    /* warnings issued wrt num inodes */
  76. /*16*/    xfs_qwarncnt_t    d_bwarns;    /* warnings issued wrt disk blocks */
  77. /*32*/    __int32_t    d_pad0;        /* 64 bit align */
  78. /*64*/    xfs_qcnt_t    d_rtb_hardlimit;/* absolute limit on realtime blks */
  79. /*64*/    xfs_qcnt_t    d_rtb_softlimit;/* preferred limit on RT disk blks */
  80. /*64*/    xfs_qcnt_t    d_rtbcount;    /* realtime blocks owned */
  81. /*32*/    __int32_t    d_rtbtimer;    /* similar to above; for RT disk blocks */
  82. /*16*/    xfs_qwarncnt_t    d_rtbwarns;    /* warnings issued wrt RT disk blocks */
  83. /*16*/    __uint16_t    d_pad;
  84. } xfs_disk_dquot_t;
  85.  
  86. /*
  87.  * This is what goes on disk. This is separated from the xfs_disk_dquot because
  88.  * carrying the unnecessary padding would be a waste of memory.
  89.  */
  90. typedef struct xfs_dqblk {
  91.     xfs_disk_dquot_t  dd_diskdq;    /* portion that lives incore as well */
  92.     char          dd_fill[32];    /* filling for posterity */
  93. } xfs_dqblk_t;
  94.  
  95. /*
  96.  * flags for q_flags field in the dquot.
  97.  */
  98. #define XFS_DQ_USER        0x0001        /* a user quota */
  99. /* #define XFS_DQ_PROJ        0x0002        -- project quota (IRIX) */
  100. #define XFS_DQ_GROUP        0x0004        /* a group quota */
  101. #define XFS_DQ_FLOCKED        0x0008        /* flush lock taken */
  102. #define XFS_DQ_DIRTY        0x0010        /* dquot is dirty */
  103. #define XFS_DQ_WANT        0x0020        /* for lookup/reclaim race */
  104. #define XFS_DQ_INACTIVE        0x0040        /* dq off mplist & hashlist */
  105. #define XFS_DQ_MARKER        0x0080        /* sentinel */
  106.  
  107. /*
  108.  * In the worst case, when both user and group quotas are on,
  109.  * we can have a max of three dquots changing in a single transaction.
  110.  */
  111. #define XFS_DQUOT_LOGRES(mp)    (sizeof(xfs_disk_dquot_t) * 3)
  112.  
  113.  
  114. /*
  115.  * These are the structures used to lay out dquots and quotaoff
  116.  * records on the log. Quite similar to those of inodes.
  117.  */
  118.  
  119. /*
  120.  * log format struct for dquots.
  121.  * The first two fields must be the type and size fitting into
  122.  * 32 bits : log_recovery code assumes that.
  123.  */
  124. typedef struct xfs_dq_logformat {
  125.     __uint16_t        qlf_type;      /* dquot log item type */
  126.     __uint16_t        qlf_size;      /* size of this item */
  127.     xfs_dqid_t        qlf_id;           /* usr/grp id number : 32 bits */
  128.     __int64_t        qlf_blkno;     /* blkno of dquot buffer */
  129.     __int32_t        qlf_len;       /* len of dquot buffer */
  130.     __uint32_t        qlf_boffset;   /* off of dquot in buffer */
  131. } xfs_dq_logformat_t;
  132.  
  133. /*
  134.  * log format struct for QUOTAOFF records.
  135.  * The first two fields must be the type and size fitting into
  136.  * 32 bits : log_recovery code assumes that.
  137.  * We write two LI_QUOTAOFF logitems per quotaoff, the last one keeps a pointer
  138.  * to the first and ensures that the first logitem is taken out of the AIL
  139.  * only when the last one is securely committed.
  140.  */
  141. typedef struct xfs_qoff_logformat {
  142.     unsigned short        qf_type;    /* quotaoff log item type */
  143.     unsigned short        qf_size;    /* size of this item */
  144.     unsigned int        qf_flags;    /* USR and/or GRP */
  145.     char            qf_pad[12];    /* padding for future */
  146. } xfs_qoff_logformat_t;
  147.  
  148.  
  149. /*
  150.  * Disk quotas status in m_qflags, and also sb_qflags. 16 bits.
  151.  */
  152. #define XFS_UQUOTA_ACCT    0x0001  /* user quota accounting ON */
  153. #define XFS_UQUOTA_ENFD    0x0002  /* user quota limits enforced */
  154. #define XFS_UQUOTA_CHKD    0x0004  /* quotacheck run on usr quotas */
  155. #define XFS_PQUOTA_ACCT    0x0008  /* (IRIX) project quota accounting ON */
  156. #define XFS_GQUOTA_ENFD    0x0010  /* group quota limits enforced */
  157. #define XFS_GQUOTA_CHKD    0x0020  /* quotacheck run on grp quotas */
  158. #define XFS_GQUOTA_ACCT    0x0040  /* group quota accounting ON */
  159.  
  160. /*
  161.  * Incore only flags for quotaoff - these bits get cleared when quota(s)
  162.  * are in the process of getting turned off. These flags are in m_qflags but
  163.  * never in sb_qflags.
  164.  */
  165. #define XFS_UQUOTA_ACTIVE    0x0080  /* uquotas are being turned off */
  166. #define XFS_GQUOTA_ACTIVE    0x0100  /* gquotas are being turned off */
  167.  
  168. /*
  169.  * Checking XFS_IS_*QUOTA_ON() while holding any inode lock guarantees
  170.  * quota will be not be switched off as long as that inode lock is held.
  171.  */
  172. #define XFS_IS_QUOTA_ON(mp)    ((mp)->m_qflags & (XFS_UQUOTA_ACTIVE | \
  173.                            XFS_GQUOTA_ACTIVE))
  174. #define XFS_IS_UQUOTA_ON(mp)    ((mp)->m_qflags & XFS_UQUOTA_ACTIVE)
  175. #define XFS_IS_GQUOTA_ON(mp)    ((mp)->m_qflags & XFS_GQUOTA_ACTIVE)
  176.  
  177. /*
  178.  * Flags to tell various functions what to do. Not all of these are meaningful
  179.  * to a single function. None of these XFS_QMOPT_* flags are meant to have
  180.  * persistent values (ie. their values can and will change between versions)
  181.  */
  182. #define XFS_QMOPT_DQLOCK    0x0000001 /* dqlock */
  183. #define XFS_QMOPT_DQALLOC    0x0000002 /* alloc dquot ondisk if needed */
  184. #define XFS_QMOPT_UQUOTA    0x0000004 /* user dquot requested */
  185. #define XFS_QMOPT_GQUOTA    0x0000008 /* group dquot requested */
  186. #define XFS_QMOPT_FORCE_RES    0x0000010 /* ignore quota limits */
  187. #define XFS_QMOPT_DQSUSER    0x0000020 /* don't cache super users dquot */
  188. #define XFS_QMOPT_SBVERSION    0x0000040 /* change superblock version num */
  189. #define XFS_QMOPT_QUOTAOFF    0x0000080 /* quotas are being turned off */
  190. #define XFS_QMOPT_UMOUNTING    0x0000100 /* filesys is being unmounted */
  191. #define XFS_QMOPT_DOLOG        0x0000200 /* log buf changes (in quotacheck) */
  192. #define XFS_QMOPT_DOWARN        0x0000400 /* increase warning cnt if necessary */
  193. #define XFS_QMOPT_ILOCKED    0x0000800 /* inode is already locked (excl) */
  194. #define XFS_QMOPT_DQREPAIR    0x0001000 /* repair dquot, if damaged. */
  195.  
  196. /*
  197.  * flags to xfs_trans_mod_dquot to indicate which field needs to be
  198.  * modified.
  199.  */
  200. #define XFS_QMOPT_RES_REGBLKS    0x0010000
  201. #define XFS_QMOPT_RES_RTBLKS    0x0020000
  202. #define XFS_QMOPT_BCOUNT    0x0040000
  203. #define XFS_QMOPT_ICOUNT    0x0080000
  204. #define XFS_QMOPT_RTBCOUNT    0x0100000
  205. #define XFS_QMOPT_DELBCOUNT    0x0200000
  206. #define XFS_QMOPT_DELRTBCOUNT    0x0400000
  207. #define XFS_QMOPT_RES_INOS    0x0800000
  208.  
  209. /*
  210.  * flags for dqflush and dqflush_all.
  211.  */
  212. #define XFS_QMOPT_SYNC        0x1000000
  213. #define XFS_QMOPT_ASYNC        0x2000000
  214. #define XFS_QMOPT_DELWRI    0x4000000
  215.  
  216. /*
  217.  * flags for dqalloc.
  218.  */
  219. #define XFS_QMOPT_INHERIT    0x8000000
  220.  
  221. /*
  222.  * flags to xfs_trans_mod_dquot.
  223.  */
  224. #define XFS_TRANS_DQ_RES_BLKS    XFS_QMOPT_RES_REGBLKS
  225. #define XFS_TRANS_DQ_RES_RTBLKS    XFS_QMOPT_RES_RTBLKS
  226. #define XFS_TRANS_DQ_RES_INOS    XFS_QMOPT_RES_INOS
  227. #define XFS_TRANS_DQ_BCOUNT    XFS_QMOPT_BCOUNT
  228. #define XFS_TRANS_DQ_DELBCOUNT    XFS_QMOPT_DELBCOUNT
  229. #define XFS_TRANS_DQ_ICOUNT    XFS_QMOPT_ICOUNT
  230. #define XFS_TRANS_DQ_RTBCOUNT    XFS_QMOPT_RTBCOUNT
  231. #define XFS_TRANS_DQ_DELRTBCOUNT XFS_QMOPT_DELRTBCOUNT
  232.  
  233.  
  234. #define XFS_QMOPT_QUOTALL    (XFS_QMOPT_UQUOTA|XFS_QMOPT_GQUOTA)
  235. #define XFS_QMOPT_RESBLK_MASK    (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
  236.  
  237. #ifdef __KERNEL__
  238. /*
  239.  * This check is done typically without holding the inode lock;
  240.  * that may seem racey, but it is harmless in the context that it is used.
  241.  * The inode cannot go inactive as long a reference is kept, and
  242.  * therefore if dquot(s) were attached, they'll stay consistent.
  243.  * If, for example, the ownership of the inode changes while
  244.  * we didn't have the inode locked, the appropriate dquot(s) will be
  245.  * attached atomically.
  246.  */
  247. #define XFS_NOT_DQATTACHED(mp, ip) ((XFS_IS_UQUOTA_ON(mp) &&\
  248.                      (ip)->i_udquot == NULL) || \
  249.                     (XFS_IS_GQUOTA_ON(mp) && \
  250.                      (ip)->i_gdquot == NULL))
  251.  
  252. #define XFS_QM_NEED_QUOTACHECK(mp) ((XFS_IS_UQUOTA_ON(mp) && \
  253.                      (mp->m_sb.sb_qflags & \
  254.                       XFS_UQUOTA_CHKD) == 0) || \
  255.                     (XFS_IS_GQUOTA_ON(mp) && \
  256.                      (mp->m_sb.sb_qflags & \
  257.                       XFS_GQUOTA_CHKD) == 0))
  258.  
  259. #define XFS_MOUNT_QUOTA_ALL    (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
  260.                  XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\
  261.                  XFS_GQUOTA_ENFD|XFS_GQUOTA_CHKD)
  262. #define XFS_MOUNT_QUOTA_MASK    (XFS_MOUNT_QUOTA_ALL | XFS_UQUOTA_ACTIVE | \
  263.                  XFS_GQUOTA_ACTIVE)
  264.  
  265.  
  266. /*
  267.  * The structure kept inside the xfs_trans_t keep track of dquot changes
  268.  * within a transaction and apply them later.
  269.  */
  270. typedef struct xfs_dqtrx {
  271.     struct xfs_dquot *qt_dquot;      /* the dquot this refers to */
  272.     ulong        qt_blk_res;      /* blks reserved on a dquot */
  273.     ulong        qt_blk_res_used;  /* blks used from the reservation */
  274.     ulong        qt_ino_res;      /* inode reserved on a dquot */
  275.     ulong        qt_ino_res_used;  /* inodes used from the reservation */
  276.     long        qt_bcount_delta;  /* dquot blk count changes */
  277.     long        qt_delbcnt_delta; /* delayed dquot blk count changes */
  278.     long        qt_icount_delta;  /* dquot inode count changes */
  279.     ulong        qt_rtblk_res;      /* # blks reserved on a dquot */
  280.     ulong        qt_rtblk_res_used;/* # blks used from reservation */
  281.     long        qt_rtbcount_delta;/* dquot realtime blk changes */
  282.     long        qt_delrtb_delta;  /* delayed RT blk count changes */
  283. } xfs_dqtrx_t;
  284.  
  285. /*
  286.  * Dquot transaction functions, used if quota is enabled.
  287.  */
  288. typedef void    (*qo_dup_dqinfo_t)(struct xfs_trans *, struct xfs_trans *);
  289. typedef void    (*qo_mod_dquot_byino_t)(struct xfs_trans *,
  290.                 struct xfs_inode *, uint, long);
  291. typedef void    (*qo_free_dqinfo_t)(struct xfs_trans *);
  292. typedef void    (*qo_apply_dquot_deltas_t)(struct xfs_trans *);
  293. typedef void    (*qo_unreserve_and_mod_dquots_t)(struct xfs_trans *);
  294. typedef int    (*qo_reserve_quota_nblks_t)(
  295.                 struct xfs_trans *, struct xfs_mount *,
  296.                 struct xfs_inode *, long, long, uint);
  297. typedef int    (*qo_reserve_quota_bydquots_t)(
  298.                 struct xfs_trans *, struct xfs_mount *,
  299.                 struct xfs_dquot *, struct xfs_dquot *,
  300.                 long, long, uint);
  301. typedef struct xfs_dqtrxops {
  302.     qo_dup_dqinfo_t            qo_dup_dqinfo;
  303.     qo_free_dqinfo_t        qo_free_dqinfo;
  304.     qo_mod_dquot_byino_t        qo_mod_dquot_byino;
  305.     qo_apply_dquot_deltas_t        qo_apply_dquot_deltas;
  306.     qo_reserve_quota_nblks_t    qo_reserve_quota_nblks;
  307.     qo_reserve_quota_bydquots_t    qo_reserve_quota_bydquots;
  308.     qo_unreserve_and_mod_dquots_t    qo_unreserve_and_mod_dquots;
  309. } xfs_dqtrxops_t;
  310.  
  311. #define XFS_DQTRXOP(mp, tp, op, args...) \
  312.         ((mp)->m_qm_ops.xfs_dqtrxops ? \
  313.         ((mp)->m_qm_ops.xfs_dqtrxops->op)(tp, ## args) : 0)
  314.  
  315. #define XFS_DQTRXOP_VOID(mp, tp, op, args...) \
  316.         ((mp)->m_qm_ops.xfs_dqtrxops ? \
  317.         ((mp)->m_qm_ops.xfs_dqtrxops->op)(tp, ## args) : (void)0)
  318.  
  319. #define XFS_TRANS_DUP_DQINFO(mp, otp, ntp) \
  320.     XFS_DQTRXOP_VOID(mp, otp, qo_dup_dqinfo, ntp)
  321. #define XFS_TRANS_FREE_DQINFO(mp, tp) \
  322.     XFS_DQTRXOP_VOID(mp, tp, qo_free_dqinfo)
  323. #define XFS_TRANS_MOD_DQUOT_BYINO(mp, tp, ip, field, delta) \
  324.     XFS_DQTRXOP_VOID(mp, tp, qo_mod_dquot_byino, ip, field, delta)
  325. #define XFS_TRANS_APPLY_DQUOT_DELTAS(mp, tp) \
  326.     XFS_DQTRXOP_VOID(mp, tp, qo_apply_dquot_deltas)
  327. #define XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip, nblks, ninos, fl) \
  328.     XFS_DQTRXOP(mp, tp, qo_reserve_quota_nblks, mp, ip, nblks, ninos, fl)
  329. #define XFS_TRANS_RESERVE_QUOTA_BYDQUOTS(mp, tp, ud, gd, nb, ni, fl) \
  330.     XFS_DQTRXOP(mp, tp, qo_reserve_quota_bydquots, mp, ud, gd, nb, ni, fl)
  331. #define XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp, tp) \
  332.     XFS_DQTRXOP_VOID(mp, tp, qo_unreserve_and_mod_dquots)
  333.  
  334. #define XFS_TRANS_RESERVE_BLKQUOTA(mp, tp, ip, nblks) \
  335.     XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip, nblks, 0, \
  336.                 XFS_QMOPT_RES_REGBLKS)
  337. #define XFS_TRANS_RESERVE_BLKQUOTA_FORCE(mp, tp, ip, nblks) \
  338.     XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip, nblks, 0, \
  339.                 XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES)
  340. #define XFS_TRANS_UNRESERVE_BLKQUOTA(mp, tp, ip, nblks) \
  341.     XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip, -(nblks), 0, \
  342.                 XFS_QMOPT_RES_REGBLKS)
  343. #define XFS_TRANS_RESERVE_QUOTA(mp, tp, ud, gd, nb, ni, f) \
  344.     XFS_TRANS_RESERVE_QUOTA_BYDQUOTS(mp, tp, ud, gd, nb, ni, \
  345.                 f | XFS_QMOPT_RES_REGBLKS)
  346. #define XFS_TRANS_UNRESERVE_QUOTA(mp, tp, ud, gd, nb, ni, f) \
  347.     XFS_TRANS_RESERVE_QUOTA_BYDQUOTS(mp, tp, ud, gd, -(nb), -(ni), \
  348.                 f | XFS_QMOPT_RES_REGBLKS)
  349.  
  350. extern int xfs_qm_dqcheck(xfs_disk_dquot_t *, xfs_dqid_t, uint, uint, char *);
  351.  
  352. extern struct bhv_vfsops xfs_qmops;
  353.  
  354. #endif    /* __KERNEL__ */
  355.  
  356. #endif    /* __XFS_QUOTA_H__ */
  357.